//package com.zg.nacos.manager;
//
///**
// * <p>Description: </p>
// *
// * @author zhanfeng.liang
// * @since 2025/6/27 20:58
// */
//
//
//import com.alibaba.nacos.api.config.ConfigService;
//import com.alibaba.nacos.api.exception.NacosException;
//import com.alibaba.nacos.api.naming.NamingService;
//import com.zg.nacos.domain.bo.InstanceInfo;
//import com.zg.nacos.domain.req.ConfigInfoReq;
//import com.zg.nacos.manager.InstanceManager;
//import com.zg.nacos.manager.NamingServiceManager;
//
//import lombok.RequiredArgsConstructor;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.http.ResponseEntity;
//import org.springframework.scheduling.annotation.Scheduled;
//import org.springframework.stereotype.Component;
//import org.springframework.web.client.RestTemplate;
//
//import java.util.List;
//import java.util.Map;
//import java.util.concurrent.ConcurrentHashMap;
//
//@Slf4j
//@Component
//@RequiredArgsConstructor
//public class HealthCheckTask {
//    // 配置参数
//    private static final int MAX_FAILURE_COUNT = 3; // 最大失败次数阈值
//    private static final long INSTANCE_DEREGISTER_DELAY = 300000; // 实例注销延迟 (5分钟)
//    private static final long SERVICE_DEREGISTER_DELAY = 600000; // 服务注销延迟 (10分钟)
//    private static final long HEALTH_CHECK_INTERVAL = 30000; // 健康检查间隔 (30秒)
//
//    // 依赖注入
//    private final InstanceManager instanceManager;
//    private final NamingServiceManager namingServiceManager;
//    private final RestTemplate restTemplate;
//
//    // 待注销服务列表 [serviceKey -> 标记时间]
//    private final Map<String, Long> servicesToDeregister = new ConcurrentHashMap<>();
//
//    /**
//     * 定时执行健康检查任务
//     */
//    @Scheduled(fixedRate = HEALTH_CHECK_INTERVAL)
//    public void checkAllInstances() {
//        try {
//            // 1. 检查所有实例的健康状态
//            checkIndividualInstances();
//
//            // 2. 检查服务集群健康状态
//            //checkServiceClusterHealth();
//        } catch (Exception e) {
//            log.error("健康检查任务执行失败", e);
//        }
//    }
//
//    /**
//     * 检查单个实例的健康状态
//     */
//    private void checkIndividualInstances() {
//        instanceManager.getAllInstances().values().forEach(instance -> {
//            // 处理已标记为不健康且超过延迟时间的实例
//            if (instance.getHealthStatus() == InstanceInfo.HealthStatus.UNHEALTHY) {
//                handleDelayedInstanceDeregister(instance);
//                return;
//            }
//
//            // 执行健康检查
//            try {
//                ResponseEntity<String> response = restTemplate.getForEntity(
//                        instance.getHttpHealthCheckUrl(), String.class);
//
//                if (response.getStatusCode().is2xxSuccessful()) {
//                    handleHealthyInstance(instance);
//                } else {
//                    handleUnhealthyInstance(instance);
//                }
//            } catch (Exception e) {
//                log.warn("健康检查失败: {} | 错误: {}", instance.getHealthCheckUrl(), e.getMessage());
//                handleUnhealthyInstance(instance);
//            }
//        });
//    }
//
//    /**
//     * 处理健康的实例
//     */
//    private void handleHealthyInstance(InstanceInfo instance) {
//        // 重置健康状态
//        instance.markHealthy();
//        log.info("实例恢复健康: {}@{}:{}",
//                instance.getServiceName(), instance.getIp(), instance.getPort());
//    }
//
//    /**
//     * 处理不健康的实例
//     */
//    private void handleUnhealthyInstance(InstanceInfo instance) {
//        // 增加失败计数
//        instance.incrementFailureCount();
//
//        if (instance.getFailureCount() >= MAX_FAILURE_COUNT) {
//            // 达到阈值：标记为不健康
//            instance.markUnhealthy();
//            log.error("实例连续失败{}次，标记为不健康: {}@{}:{}",
//                    MAX_FAILURE_COUNT,
//                    instance.getServiceName(),
//                    instance.getIp(),
//                    instance.getPort());
//
//            // 检查服务集群状态
//            checkServiceClusterStatus(instance);
//        } else {
//            // 未达阈值：记录警告
//            log.warn("实例检查失败: {}/{} | {}@{}:{}",
//                    instance.getFailureCount(),
//                    MAX_FAILURE_COUNT,
//                    instance.getServiceName(),
//                    instance.getIp(),
//                    instance.getPort());
//        }
//    }
//
//    /**
//     * 处理延迟注销的实例
//     */
//    private void handleDelayedInstanceDeregister(InstanceInfo instance) {
//        long unhealthyDuration = System.currentTimeMillis() - instance.getUnhealthyTime();
//
//        if (unhealthyDuration > INSTANCE_DEREGISTER_DELAY) {
//            deregisterInstance(instance);
//        } else {
//            log.info("实例等待注销: {}@{}:{} | 已等待: {}/{}秒",
//                    instance.getServiceName(), instance.getIp(), instance.getPort(),
//                    unhealthyDuration / 1000, INSTANCE_DEREGISTER_DELAY / 1000);
//        }
//    }
//
//    /**
//     * 注销单个实例
//     */
//    private void deregisterInstance(InstanceInfo instance) {
//        try {
//            log.warn("注销实例: {}@{}:{}",
//                    instance.getServiceName(), instance.getIp(), instance.getPort());
//
//            // 从Nacos注销
//            NamingService namingService = namingServiceManager.getNamingService(instance.getNamespace());
//            namingService.deregisterInstance(
//                    instance.getServiceName(),
//                    instance.getIp(),
//                    instance.getPort()
//            );
//
//
//            // 从管理器中移除
//            instanceManager.removeInstance(
//                    instance.getNamespace(),
//                    instance.getServiceName(),
//                    instance.getIp(),
//                    instance.getPort()
//            );
//        } catch (Exception e) {
//            log.error("注销实例失败: {}", instance, e);
//        }
//    }
//
//    /**
//     * 检查服务集群状态
//     */
//    private void checkServiceClusterStatus(InstanceInfo instance) {
//        String namespace = instance.getNamespace();
//        String serviceName = instance.getServiceName();
//        String serviceKey = namespace + "@" + serviceName;
//
//        // 获取服务的所有实例
//        List<InstanceInfo> instances = instanceManager.getServiceInstances(namespace, serviceName);
//
//        // 统计健康实例数量
//        long healthyCount = instances.stream()
//                .filter(inst -> inst.getHealthStatus() == InstanceInfo.HealthStatus.HEALTHY)
//                .count();
//
//        // 如果没有健康实例，标记服务待注销
//        if (healthyCount == 0) {
//            servicesToDeregister.put(serviceKey, System.currentTimeMillis());
//            log.error("服务所有实例不可用，标记待注销: {}", serviceKey);
//        }
//    }
//
//    /**
//     * 检查服务集群健康状态
//     */
//    private void checkServiceClusterHealth() {
//        servicesToDeregister.entrySet().removeIf(entry -> {
//            String serviceKey = entry.getKey();
//            long markTime = entry.getValue();
//
//            // 拆分命名空间和服务名
//            String[] parts = serviceKey.split("@", 2);
//            String namespace = parts[0];
//            String serviceName = parts[1];
//
//            // 获取服务的所有实例
//            List<InstanceInfo> instances = instanceManager.getServiceInstances(namespace, serviceName);
//
//            // 统计健康实例数量
//            long healthyCount = instances.stream()
//                    .filter(inst -> inst.getHealthStatus() == InstanceInfo.HealthStatus.HEALTHY)
//                    .count();
//
//            // 如果有健康实例，移出注销列表
//            if (healthyCount > 0) {
//                log.info("服务恢复健康实例: {} | 健康实例数: {}", serviceKey, healthyCount);
//                return true; // 移出注销列表
//            }
//
//            // 检查是否达到服务注销延迟时间
//            long unhealthyDuration = System.currentTimeMillis() - markTime;
//            if (unhealthyDuration > SERVICE_DEREGISTER_DELAY) {
//                deregisterService(namespace, serviceName);
//                return true; // 移出注销列表
//            }
//
//            // 记录等待状态
//            log.info("服务等待注销: {} | 已等待: {}/{}秒",
//                    serviceKey,
//                    unhealthyDuration / 1000,
//                    SERVICE_DEREGISTER_DELAY / 1000);
//            return false; // 保留在注销列表
//        });
//    }
//
//    /**
//     * 注销整个服务
//     */
//    private void deregisterService(String namespace, String serviceName) {
//        String serviceKey = namespace + "@" + serviceName;
//
//        try {
//            log.warn("开始注销服务: {}", serviceKey);
//            NamingService namingService = namingServiceManager.getNamingService(namespace);
//
//            // 获取所有实例
//            List<InstanceInfo> instances = instanceManager.getServiceInstances(namespace, serviceName);
//
//            // 注销每个实例
//            for (InstanceInfo instance : instances) {
//                try {
//                    log.info("注销服务实例: {}@{}:{}",
//                            instance.getServiceName(), instance.getIp(), instance.getPort());
//
//                    namingService.deregisterInstance(
//                            instance.getServiceName(),
//                            instance.getIp(),
//                            instance.getPort()
//                    );
//                } catch (NacosException e) {
//                    log.error("注销实例失败: {}", instance, e);
//                }
//
//                // 从管理器中移除
//                instanceManager.removeInstance(
//                        instance.getNamespace(),
//                        instance.getServiceName(),
//                        instance.getIp(),
//                        instance.getPort()
//                );
//            }
//
//            log.warn("服务注销完成: {}", serviceKey);
//        } catch (NacosException e) {
//            log.error("获取NamingService失败: {} | {}", namespace, e.getMessage());
//        }
//    }
//}